// 存储用户信息的键名
const USER_INFO_KEY = 'userInfo';
// 存储token的键名
const TOKEN_KEY = 'token';
// 存储用户角色的键名
const ROLES_KEY = 'userRoles';
// 存储用户权限的键名
const PERMISSIONS_KEY = 'userPermissions';

/**
 * 通用存储方法
 * @param {string} key - 存储键名
 * @param {any} value - 存储值
 */
function setStorage(key, value) {
  try {
    wx.setStorageSync(key, value);
  } catch (e) {
    console.error('存储数据失败:', e);
  }
}

/**
 * 通用获取存储方法
 * @param {string} key - 存储键名
 * @returns {any} 存储的值或null
 */
function getStorage(key) {
  try {
    const value = wx.getStorageSync(key);
    return value;
  } catch (e) {
    console.error('获取存储数据失败:', e);
    return null;
  }
}

/**
 * 通用删除存储方法
 * @param {string} key - 存储键名
 */
function removeStorage(key) {
  try {
    wx.removeStorageSync(key);
  } catch (e) {
    console.error('删除存储数据失败:', e);
  }
}

/**
 * 存储用户信息到本地
 * @param {Object} userInfo - 用户信息对象
 */
function setUserInfo(userInfo) {
  try {
    wx.setStorageSync(USER_INFO_KEY, userInfo);
  } catch (e) {
    console.error('存储用户信息失败:', e);
  }
}

/**
 * 存储token到本地
 * @param {string} token - 用户token
 */
function setToken(token) {
  try {
    wx.setStorageSync(TOKEN_KEY, token);
  } catch (e) {
    console.error('存储token失败:', e);
  }
}

/**
 * 存储完整的用户认证信息
 * @param {Object} userInfo - 用户信息对象
 * @param {string} token - 用户token
 * @param {Array} roles - 用户角色数组
 * @param {Array} permissions - 用户权限数组
 */
function setAuthData(userInfo, token, roles = [], permissions = []) {
  try {
    wx.setStorageSync(USER_INFO_KEY, userInfo);
    wx.setStorageSync(TOKEN_KEY, token);
    wx.setStorageSync(ROLES_KEY, roles);
    wx.setStorageSync(PERMISSIONS_KEY, permissions);
    console.log('用户认证信息保存成功');
  } catch (e) {
    console.error('存储认证数据失败:', e);
  }
}

/**
 * 存储用户角色到本地
 * @param {Array} roles - 用户角色数组
 */
function setUserRoles(roles) {
  try {
    wx.setStorageSync(ROLES_KEY, roles || []);
  } catch (e) {
    console.error('存储用户角色失败:', e);
  }
}

/**
 * 存储用户权限到本地
 * @param {Array} permissions - 用户权限数组
 */
function setUserPermissions(permissions) {
  try {
    wx.setStorageSync(PERMISSIONS_KEY, permissions || []);
  } catch (e) {
    console.error('存储用户权限失败:', e);
  }
}

/**
 * 从本地获取用户信息
 * @returns {Object|null} 用户信息对象或null
 */
function getUserInfo() {
  try {
    const userInfo = wx.getStorageSync(USER_INFO_KEY);
    return userInfo ? userInfo : null;
  } catch (e) {
    console.error('获取用户信息失败:', e);
    return null;
  }
}

/**
 * 从本地获取用户ID
 * @returns {string|null} 用户ID字符串或null
 */
function getUserId() {
  try {
    const userInfo = wx.getStorageSync(USER_INFO_KEY);
    console.log('storageUtil - 获取到的用户信息:', userInfo);

    if (!userInfo) {
      console.log('storageUtil - 用户信息为空');
      return null;
    }

    // 尝试多种可能的用户ID字段名
    const possibleIdFields = ['id', 'userId', 'user_id', 'uid', 'ID', 'UserId', 'UserID'];

    for (let field of possibleIdFields) {
      if (userInfo[field] !== undefined && userInfo[field] !== null && userInfo[field] !== '') {
        console.log(`storageUtil - 找到用户ID字段: ${field} = ${userInfo[field]}`);
        return String(userInfo[field]); // 确保返回字符串
      }
    }

    console.log('storageUtil - 未找到有效的用户ID字段');
    console.log('storageUtil - 用户信息的所有字段:', Object.keys(userInfo));

    return null;
  } catch (e) {
    console.error('storageUtil - 获取用户ID失败:', e);
    return null;
  }
}

/**
 * 从本地获取token
 * @returns {string|null} token字符串或null
 */
function getToken() {
  try {
    // 首先尝试从TOKEN_KEY获取
    let token = wx.getStorageSync(TOKEN_KEY);

    if (token) {

      return token;
    }

    // 如果TOKEN_KEY没有，尝试从用户信息中获取
    const userInfo = wx.getStorageSync(USER_INFO_KEY);
    if (userInfo) {
      const possibleTokenFields = ['token', 'accessToken', 'access_token', 'authToken', 'auth_token', 'Token', 'AccessToken'];

      for (let field of possibleTokenFields) {
        if (userInfo[field] !== undefined && userInfo[field] !== null && userInfo[field] !== '') {
          console.log(`storageUtil - 从用户信息中找到token字段: ${field}`);
          return String(userInfo[field]);
        }
      }
    }

    console.log('storageUtil - 未找到有效的token');
    return null;
  } catch (e) {
    console.error('获取token失败:', e);
    return null;
  }
}

/**
 * 清除本地存储的用户信息
 */
function removeUserInfo() {
  try {
    wx.removeStorageSync(USER_INFO_KEY);
  } catch (e) {
    console.error('清除用户信息失败:', e);
  }
}

/**
 * 清除本地存储的token
 */
function removeToken() {
  try {
    wx.removeStorageSync(TOKEN_KEY);
  } catch (e) {
    console.error('清除token失败:', e);
  }
}

/**
 * 清除本地存储的所有认证数据（用户信息、token、角色、权限）
 */
function removeAuthData() {
  try {
    wx.removeStorageSync(USER_INFO_KEY);
    wx.removeStorageSync(TOKEN_KEY);
    wx.removeStorageSync(ROLES_KEY);
    wx.removeStorageSync(PERMISSIONS_KEY);
    console.log('用户认证信息清除成功');
  } catch (e) {
    console.error('清除认证数据失败:', e);
  }
}

/**
 * 检查存储状态，帮助调试
 * @returns {Object} 存储状态信息
 */
function checkStorageStatus() {
  try {
    const allStorage = wx.getStorageInfoSync();
    const userInfo = wx.getStorageSync(USER_INFO_KEY);
    const token = wx.getStorageSync(TOKEN_KEY);

    const status = {
      totalKeys: allStorage.keys.length,
      allKeys: allStorage.keys,
      userInfoExists: !!userInfo,
      userInfoKeys: userInfo ? Object.keys(userInfo) : [],
      tokenExists: !!token,
      userInfo: userInfo,
      token: token
    };

    console.log('storageUtil - 存储状态检查:', status);
    return status;
  } catch (e) {
    console.error('storageUtil - 检查存储状态失败:', e);
    return { error: e.message };
  }
}

// 导出所有函数
module.exports = {
  setStorage,
  getStorage,
  removeStorage,
  setUserInfo,
  setToken,
  setAuthData,
  setUserRoles,
  setUserPermissions,
  getUserInfo,
  getUserId,
  getToken,
  removeUserInfo,
  removeToken,
  removeAuthData,
  checkStorageStatus
};
